﻿using System;
using System.Collections.Generic;
using System.Linq;
using EnterpriseLibraryWrapper;
using itau.im.dado;
using itau.im.entidade;
using Itau.IM.CAS;

namespace itau.im.negocio
{
    public class CurvaBS : ICurvaBS
    {
        #region Metodos

        public List<Curva> ObterCurvasPorCodigoGrupoParametros(int codigoGrupoParametro, DateTime dataBase)
        {
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                return curvaDAO.ObterCurvasPorCodigoGrupoParametros(codigoGrupoParametro, dataBase);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return new List<Curva>();
        }

        public IList<GradeExecucaoCurva> ObterGradesExecucaoCurvasAtivas(TimeSpan horaUltimaExecucao, TimeSpan proximaExecucao)
        {
            //Instância o objeto DAO
            ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

            // Declara os objetosna memória.
            IList<GradeExecucaoCurva> listaGradesExecucaoCurvasAtivas = new List<GradeExecucaoCurva>();
            IList<RegistroGradeExecucaoCurva> listaGrade = null;
            DateTime proximaExecucaoAuxiliar;
            DateTime horaUltimaExecucaoTemp;
            DateTime proximaExecucaoTemp;
            try
            {

                // Obtem as Grades Execução ativas.
                listaGradesExecucaoCurvasAtivas = curvaDAO.ObterGradesExecucaoCurvasAtivas();

                // Transfere os valore para variaéveis do tipo datetime(pois o metodo a ser chamada espera esse tipo de variável como parâmetro)
                horaUltimaExecucaoTemp = Convert.ToDateTime(string.Format("{0}:{1}:{2}", horaUltimaExecucao.Hours, horaUltimaExecucao.Minutes, horaUltimaExecucao.Seconds));
                proximaExecucaoTemp = Convert.ToDateTime(string.Format("{0}:{1}:{2}", proximaExecucao.Hours, proximaExecucao.Minutes, proximaExecucao.Seconds));

                if (proximaExecucao <= horaUltimaExecucao)
                {
                    proximaExecucaoAuxiliar = Convert.ToDateTime("23:59:59");

                    // Para cada GradeExecucaoCurva obtida pelo método ObterGradesExecucaoCurvasAtivas
                    foreach (GradeExecucaoCurva objGrades in listaGradesExecucaoCurvasAtivas)
                    {
                        // Obtem a grade de execução curva pelo gange de horario.
                        listaGrade = curvaDAO.ObterRegistrosGradeExecucaoCurvaPorCurvaERangeHorario(objGrades.CodigoCurva,
                                                                                                    horaUltimaExecucaoTemp,
                                                                                                    proximaExecucaoAuxiliar);
                        // Se a consulta retornou dados.
                        if (listaGrade != null)
                            objGrades.registroGradeExecucaoCurva = listaGrade.ToList<RegistroGradeExecucaoCurva>();
                    }

                    horaUltimaExecucaoTemp = Convert.ToDateTime("00:00:00");


                    // Para cada GradeExecucaoCurva obtida pelo método ObterGradesExecucaoCurvasAtivas
                    foreach (GradeExecucaoCurva objGrades in listaGradesExecucaoCurvasAtivas)
                    {
                        // Obtem a grade de execução curva pelo gange de horario.
                        listaGrade = curvaDAO.ObterRegistrosGradeExecucaoCurvaPorCurvaERangeHorario(objGrades.CodigoCurva,
                                                                                                    horaUltimaExecucaoTemp,
                                                                                                    proximaExecucaoTemp);
                        // Se a consulta retornou dados.
                        if (listaGrade != null)
                        {
                            // Se ja existirem registros na propriedade
                            if (objGrades.registroGradeExecucaoCurva != null && objGrades.registroGradeExecucaoCurva.Count > 0)
                                // Adiciona os registros obtidoa os ja existentes.
                                objGrades.registroGradeExecucaoCurva.AddRange(listaGrade.ToList<RegistroGradeExecucaoCurva>());
                            else
                                // Adiciona os registros obtidoa.
                                objGrades.registroGradeExecucaoCurva = listaGrade.ToList<RegistroGradeExecucaoCurva>();
                        }

                    }
                }
                else
                {
                    // Para cada GradeExecucaoCurva obtida pelo método ObterGradesExecucaoCurvasAtivas
                    foreach (GradeExecucaoCurva objGrades in listaGradesExecucaoCurvasAtivas)
                    {
                        // Obtem a grade de execução curva pelo gange de horario.
                        listaGrade = curvaDAO.ObterRegistrosGradeExecucaoCurvaPorCurvaERangeHorario(objGrades.CodigoCurva,
                                                                                                    horaUltimaExecucaoTemp,
                                                                                                    proximaExecucaoTemp);
                        // Se a consulta retornou dados.
                        if (listaGrade != null)
                            objGrades.registroGradeExecucaoCurva = listaGrade.ToList<RegistroGradeExecucaoCurva>();
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca os objetos
                listaGrade = null;
            }

            // Retorna lista obtida.
            return listaGradesExecucaoCurvasAtivas;
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : ObtemCurvaVigente                                                               <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>objeto "CurvaVigente".</returns>
        public CurvaVigente ObterCurvaVigente(int curvaID)
        {
            ICurvaDAO curvaDAO;

            try
            {
                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curvaID, Itau.IM.CAS.TipoAcesso.Consulta))
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();

                        return curvaDAO.ObterCurvaVigente(curvaID);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return new CurvaVigente();
        }

        public CurvaVigente ObterCurvaVigentePorDataReferencia(int curvaID, DateTime dataReferencia)
        {
            ICurvaDAO curvaDAO;

            try
            {
                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curvaID, Itau.IM.CAS.TipoAcesso.Consulta))
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();

                        return curvaDAO.ObterCurvaVigentePorDataReferencia(curvaID, dataReferencia);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return new CurvaVigente();
        }

        public CurvaVigente ObterCurvaBulletAssociada(int codigoCurvaPMT)
        {
            ICurvaDAO curvaDAO;
            CurvaVigente curvaVigenciaPMT;
            CurvaVigente curvaVigenciaBullet;

            try
            {
                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, codigoCurvaPMT, Itau.IM.CAS.TipoAcesso.Consulta))
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();

                        curvaVigenciaPMT = new CurvaVigente();
                        curvaVigenciaPMT = curvaDAO.ObterCurvaVigente(codigoCurvaPMT);

                        curvaVigenciaBullet = new CurvaVigente();
                        curvaVigenciaBullet = curvaDAO.ObterCurvaVigente(curvaVigenciaPMT.CodigoCurvaBasePMT);

                        return curvaVigenciaBullet;
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaVigenciaPMT = null;
                curvaVigenciaBullet = null;
            }

            return new CurvaVigente();
        }

        public IList<TipoCurva> ObterTiposCurva()
        {
            IList<TipoCurva> listaTipoCurva = null;

            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();
                listaTipoCurva = curvaDAO.ObterTiposCurva();
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return listaTipoCurva;
        }

        public Curva ObterCurvaBase(int codigoCurvaComposta)
        {
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                int codigoCurvaBase = curvaDAO.ObterCodigoCurvaBase(codigoCurvaComposta);
                return curvaDAO.ObterCurva(codigoCurvaBase);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return new Curva();
        }

        public IList<Situacao> ObterSituacoes()
        {
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                return curvaDAO.ObterSituacoes();
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return new List<Situacao>();
        }

        public IList<GradeExecucaoCurva> ObterGradesExecucaoCurva()
        {
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                return curvaDAO.ObterGradesExecucaoCurva();
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return new List<GradeExecucaoCurva>();
        }

        public IList<TipoTaxa> ObterTiposTaxa()
        {
            IList<TipoTaxa> listaTipoTaxa = null;

            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();
                listaTipoTaxa = curvaDAO.ObterTiposTaxa();
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return listaTipoTaxa;
        }

        public IList<TipoEntradaDado> ObterTiposEntradaDado()
        {
            IList<TipoEntradaDado> listaTipoEntradaDado = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaTipoEntradaDado = curvaDAO.ObterTiposEntradaDado();
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return listaTipoEntradaDado;
        }

        public Curva ObterCurva(int curvaID)
        {
            try
            {
                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curvaID, Itau.IM.CAS.TipoAcesso.Consulta))
                    {
                        return DaoFactory.getCurvaDAO().ObterCurva(curvaID);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return null;
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retornar a consulta.                                                 <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "ModalidadeCurva".</returns>
        public IList<ModalidadeCurva> ObterModalidadesCurva()
        {
            //Declara o objeto
            IList<ModalidadeCurva> listaRetorno = null;

            try
            {
                //Recupera a interface de acesso a dados
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a consulta
                listaRetorno = curvaDAO.ObterModalidadesCurva();

                //Retorna a consultaok
                return listaRetorno;

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Limpa o objeto
                listaRetorno = null;
            }

            //Retorna
            return new List<ModalidadeCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retornar a consulta.                                                 <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TaxaPontoCurva> ObterVerticesInterpolacao()
        {
            //Declara o objeto
            ICurvaDAO curvaDAO;

            try
            {
                //Instância o objeto DAO
                curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                return curvaDAO.ObterVerticesInterpolacao();

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Finaliza o objeto
                curvaDAO = null;
            }

            //retorna
            return new List<TaxaPontoCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterCategoriasMercado.                                                  <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "CategoriaMercado".</returns>
        public IList<CategoriaMercado> ObterCategoriasMercado()
        {
            //Declara o objeto
            IList<CategoriaMercado> listaRetorno = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaRetorno = curvaDAO.ObterCategoriasMercado();

                //Retorna consulta
                return listaRetorno;

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca o objeto
                listaRetorno = null;
            }

            //Retorna consulta vazia
            return new List<CategoriaMercado>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método implementado para retornar a consulta.                                   <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoPrazo".</returns>
        public IList<TipoPrazo> ObterTiposPrazo()
        {
            //Declara o objeto
            IList<TipoPrazo> listaTipoPrazo = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaTipoPrazo = curvaDAO.ObterTiposPrazo();

                //Retorna a consulta
                return listaTipoPrazo;
            }

            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            finally
            {
                //Desaloca o objeto
                listaTipoPrazo = null;
            }

            //Retorna consulta
            return new List<TipoPrazo>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método implementado para retornar a consulta.                                   <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TaxaPontoCurva> ObterMetodosExtrapolacao()
        {
            //Declara o objeto
            IList<TaxaPontoCurva> listaTipoTaxa = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaTipoTaxa = curvaDAO.ObterMetodosExtrapolacao();

                //Retorna a consulta
                return listaTipoTaxa;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca o objeto
                listaTipoTaxa = null;
            }

            //Retorna consulta
            return new List<TaxaPontoCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retorna lista do tipo ModeloCalculo                                  <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "ModeloCalculo".</returns>
        public IList<ModeloCalculo> ObterModelosCalculo()
        {
            //Declara o objeto
            IList<ModeloCalculo> listaModeloCalculo = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaModeloCalculo = curvaDAO.ObterModelosCalculo();

                //Retorna consulta
                return listaModeloCalculo;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca o objeto
                listaModeloCalculo = null;
            }

            //Retorna consulta
            return new List<ModeloCalculo>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que retorna lista do tipo TipoTaxa                                       <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TaxaPontoCurva> ObterMetodosAntepolacao()
        {
            //Declara o objeto
            IList<TaxaPontoCurva> listaTipoTaxa = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaTipoTaxa = curvaDAO.ObterMetodosAntepolacao();

                //Retorna consulta
                return listaTipoTaxa;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca o objeto
                listaTipoTaxa = null;
            }

            //Retorna consulta
            return new List<TaxaPontoCurva>();
        }

        public IList<Curva> ObterCurvas()
        {
            ICurvaDAO curvaDAO;
            IList<Curva> curvas = new List<Curva>();

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                curvas = curvaDAO.ObterCurvas();

                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<Curva>(curvas, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvas = null;
            }

            return curvas;
        }

        public IList<Curva> ObterCurvasPorTipoEntradaDado(int codTipoEntradaDado)
        {
            ICurvaDAO curvaDAO;
            IList<Curva> curvas = new List<Curva>();

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                curvas = curvaDAO.ObterCurvasPorTipoEntradaDado(codTipoEntradaDado);
                return curvas;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvas = null;
            }

            return curvas;
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método implementado para retornar a consulta.                                   <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "Cotacao".</returns>
        public IList<Cotacao> ObterCotacoes()
        {
            //Declara o objeto
            IList<Cotacao> listaCotacao = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaCotacao = curvaDAO.ObterCotacoes();

                //Retorna a consulta
                return listaCotacao;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca o objeto
                listaCotacao = null;
            }

            //Retorna consulta
            return new List<Cotacao>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterMetodosInterpolacao.                                                <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoTaxa".</returns>
        public IList<TaxaPontoCurva> ObterMetodosInterpolacao()
        {
            //Declara o objeto
            IList<TaxaPontoCurva> listaRetorno = null;

            try
            {
                //Instância o objeto DAO
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaRetorno = curvaDAO.ObterMetodosInterpolacao();

                //Retorna consulta
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca o objeto
                listaRetorno = null;
            }

            //Retorna consulta vazia
            return new List<TaxaPontoCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterMaximoExtensaoDiasCurva.                                            <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns></returns>
        public int ObterMaximoExtensaoDiasCurva(int codigoCurva)
        {
            //Declara
            ICurvaDAO curvaDAO;

            try
            {

                //Instância o objeto DAO
                curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a variavel do objeto
                return curvaDAO.ObterDadosBasicosCurva(codigoCurva).QuantidadeAnoExtensao;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca o objeto
                curvaDAO = null;
            }

            //Retorna consulta vazia
            return 0;
        }

        public int ObterMaximoDiasExtensaoCurva()
        {
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                return curvaDAO.ObterMaximoDiasExtensaoCurva();
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return 0;
        }

        public int CriarRegistroExecucaoCurvaPontos(RegistroExecucaoCurva registroExecucaoCurva)
        {
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.UsuarioAdministrador)
                    {
                        return curvaDAO.CriarRegistroExecucaoCurvaPontos(registroExecucaoCurva);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }

            return 1;
        }


        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método CriarCurva.                                                              <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns></returns>
        public void CriarCurva(Curva curva)
        {
            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.UsuarioAdministrador)
                    {
                        curvaDAO.CriarCurva(curva);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curva = null;
            }
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método RemoverCurva.                                                            <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        public void RemoverCurva(Curva curva)
        {
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.UsuarioAdministrador)
                    {
                        curvaDAO.RemoverCurva(curva);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método AtualizarCurva.                                                          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        public void AtualizarCurva(Curva curva)
        {
            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curva.CodigoCurva, Itau.IM.CAS.TipoAcesso.Ativacao))
                    {
                        curvaDAO.AtualizarCurva(curva);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
                throw ex;
            }
        }

        public void AtualizarCurvaDefault(int curvaDefault)
        {
            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                if (curvaDefault != 0)
                {
                    //Implementação de tratamento para controle de acesso
                    using (IntegracaoCAS CAS = new IntegracaoCAS())
                    {
                        if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curvaDefault, Itau.IM.CAS.TipoAcesso.Ativacao))
                        {
                            DateTime data = System.DateTime.Now;

                            curvaDAO.EncerrarVigenciaCurvaDefault(data);

                            curvaDAO.CriarCurvaDefault(curvaDefault, data);
                        }
                        else
                        {
                            System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                        }
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
        }

        public Curva ObterCurvaDefault()
        {
            ICurvaDAO curvaDAO;
            Curva curvaDefault = null;

            try
            {
                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curvaDefault.CodigoCurva, Itau.IM.CAS.TipoAcesso.Consulta))
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        curvaDefault = curvaDAO.ObterDadosBasicosCurva(curvaDAO.ObterCurvaDefault().CodigoCurva);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDefault = null;
            }

            return curvaDefault;
        }

        public Curva ObterCurvaPorNomeInterno(string nomeInterno)
        {
            ICurvaDAO curvaDAO;
            Curva curva = null;

            try
            {
                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curva.CodigoCurva, Itau.IM.CAS.TipoAcesso.Consulta))
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();
                        curva = curvaDAO.ObterCurvaPorNomeInterno(nomeInterno);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                curva = null;
            }

            return null;
        }


        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 07/01/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterCurvasLiberadasPorDataTipoModalidade                                <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="dataExecucaoCurva"></param>
        /// <param name="tipoCurva"></param>
        /// <param name="modalidadeCurva"></param>
        /// <returns>Lista do tipo Curva</returns>
        public IList<Curva> ObterCurvasLiberadasPorDataTipoModalidade(DateTime dataExecucao, int tipoCurva, int modalidade)
        {
            //Declaração do objeto
            ICurvaDAO curvaDAO;
            IList<Curva> listaretorno = null;

            try
            {
                //Instância da interface ICurvaDAO
                curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista
                listaretorno = curvaDAO.ObterCurvasLiberadasPorDataTipoModalidade(dataExecucao, tipoCurva, modalidade);

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<Curva>(listaretorno, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                listaretorno = null;
            }

            //Retorna a consulta vazia
            return new List<Curva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 30/12/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método que será implementado para converter parametros em vertices.             <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>    
        public void ConverterParametroModeloIntervaloToleranciaEmVertice(IList<ParametroModeloIntervaloTolerancia> listaParametroModeloIntervaloTolerancia,
                                                                         DateTime dataInicio, IList<CurvaExecucaoPonto> limiteInferior,
                                                                         IList<CurvaExecucaoPonto> limiteSuperior, IList<CurvaExecucaoPonto> listaPontosCurva)
        {
            int quantidadeDiasUteis;
            DateTime dataVencimento = new DateTime();
            CalendarioReguaBS calendarioRegua = new CalendarioReguaBS(dataInicio, dataInicio.AddDays(listaParametroModeloIntervaloTolerancia[listaParametroModeloIntervaloTolerancia.Count - 1].PrazoDiaCurva));

            foreach (itau.im.entidade.ParametroModeloIntervaloTolerancia listaParametro in listaParametroModeloIntervaloTolerancia)
            {
                dataVencimento = dataInicio.AddDays(listaParametro.PrazoDiaCurva);
                quantidadeDiasUteis = calendarioRegua.ObterQuantidadeDiasUteis(dataVencimento.ToString("yyyyMMdd"));

                double limiteInf = 1 - (double)listaParametro.ValorToleranciaInferior / 100;
                double limiteSup = 1 + (double)listaParametro.ValorToleranciaSuperior / 100;

                CurvaExecucaoPonto itemLimiteInferior = new CurvaExecucaoPonto();
                CurvaExecucaoPonto itemLimiteSuperior = new CurvaExecucaoPonto();

                itemLimiteInferior.DataVencimento = dataVencimento;
                itemLimiteInferior.QuantidadeDiasCorridos = listaParametro.PrazoDiaCurva;
                itemLimiteInferior.QuantidadeDiasUteis = quantidadeDiasUteis;
                itemLimiteInferior.ValorVertice = limiteInf;
                limiteInferior.Add(itemLimiteInferior);

                itemLimiteSuperior.DataVencimento = dataVencimento;
                itemLimiteSuperior.QuantidadeDiasCorridos = listaParametro.PrazoDiaCurva;
                itemLimiteSuperior.QuantidadeDiasUteis = quantidadeDiasUteis;
                itemLimiteSuperior.ValorVertice = limiteSup;
                limiteSuperior.Add(itemLimiteSuperior);
            }
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obtem ModeloIntervaloTolerancia                                                 <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>objeto "ModeloIntervaloTolerancia".</returns>
        public ModeloIntervaloTolerancia ObterIntervaloTolerancia(int modeloID)
        {
            //Declara o objeto            
            ICurvaDAO curvaDAO;

            try
            {
                //Instância o objeto DAO
                curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera e retorna o objeto
                return curvaDAO.ObterIntervaloTolerancia(modeloID);

            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca os objetos
                curvaDAO = null;
            }

            //Retorna consulta vazia
            return new ModeloIntervaloTolerancia();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 03/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obtem Lista CurvaVigente                                                        <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "CurvaVigente".</returns>
        public IList<CurvaVigente> ObterCurvasVigentes(IList<Curva> listaCurvas)
        {
            List<CurvaVigente> listaCurvasVigentes = new List<CurvaVigente>();

            try
            {
                foreach (Curva curva in listaCurvas)
                {
                    listaCurvasVigentes.Add(ObterCurvaVigente(curva.CodigoCurva));
                }

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<CurvaVigente>(listaCurvasVigentes, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaCurvasVigentes = null;
            }

            return new List<CurvaVigente>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 11/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterAcoesRetencaoCurva.                                                 <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <returns>Lista de objetos "TipoAcaoRetencaoCurva".</returns>
        public IList<TipoAcaoRetencaoCurva> ObterAcoesRetencaoCurva()
        {
            //Cria a lista TipoRetencaoCurva
            IList<TipoAcaoRetencaoCurva> listaTipoAcaoRetencaoCurva = null;

            //Declara o objeto
            ICurvaDAO curvaDAO = null;

            try
            {
                //Instancia o objeto DAO
                curvaDAO = DaoFactory.getCurvaDAO();

                //Recupera a lista de TipoAcaoRetencaoCurva
                listaTipoAcaoRetencaoCurva = curvaDAO.ObterTiposAcaoRetencaoCurva();

                //retorna a lista de TipoAcaoRetencaoCurva
                return listaTipoAcaoRetencaoCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca os objetos
                listaTipoAcaoRetencaoCurva = null;
                curvaDAO = null;
            }
            //Retorna a consulta limpa
            return new List<TipoAcaoRetencaoCurva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 17/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterFatoresCurva.                                                       <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="codigoCurva">codigoCurva</param>
        /// <param name="dataInclusaoVigencia">dataInclusaoVigencia</param>
        /// <returns>Lista de objetos "Curva".</returns>
        public IList<Curva> ObterFatoresCurva(int codigoCurva, DateTime dataInclusaoVigencia)
        {
            //Cria as Listas
            IList<ItemComposicao> listaItens = null;
            List<Curva> listaCurva = null;

            //Declara o objeto
            ICurvaDAO curvaDAO = null;

            try
            {
                //Instancia o objeto DAO
                curvaDAO = DaoFactory.getCurvaDAO();

                //Instancia a lista de Curva;
                listaCurva = new List<Curva>();

                //Recupera a lista de ItemComposicao
                listaItens = curvaDAO.ObterItensComposicao(codigoCurva, dataInclusaoVigencia);

                //Verifica se a listaItemComposicao esta vazia ou nula.
                if (listaItens != null && listaItens.Count > 0)
                {
                    //Percorre a Lista de DominioParametroAtribuicao de cada parametroAtribuicao
                    foreach (ItemComposicao itemComposicao in listaItens)
                    {
                        //Instancia o objeto tipo Curva
                        Curva curva = new Curva();

                        //Atribui o valor CodigoCurva da classe item composicao para o Codigo Curva da classe Curva
                        curva.CodigoCurva = itemComposicao.CodigoCurva;

                        //Adiciona a curva na lista de Curvas.
                        listaCurva.Add(curva);
                    }
                }

                //retorna a lista de Curva
                return listaCurva;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                //Desaloca os objetos
                listaItens = null;
                listaCurva = null;
                curvaDAO = null;
            }
            //Retorna a consulta limpa
            return new List<Curva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 12/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Obter Curvas Vigente Por Tipo Mesa Origem Categoria                             <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="mesaID">mesaID</param>
        /// <param name="tipoCurvaID">tipoCurvaID</param>
        /// <param name="categoriaID">categoriaID</param>
        /// <param name="codigoSituacaoAtiva">codigoSituacaoAtiva</param>
        /// <param name="codigoSituacaoPendente">codigoSituacaoPendente</param>
        /// <returns>Lista de CurvaVigente</returns>
        public IList<CurvaVigente> ObterCurvasVigentePorTipoMesaOrigemCategoria(int mesaID, int tipoCurvaID, int categoriaID, int codigoSituacaoAtiva, int codigoSituacaoPendente)
        {
            ICurvaDAO curvaDAO;
            IList<CurvaVigente> listaCurvasVigentes;

            try
            {
                listaCurvasVigentes = new List<CurvaVigente>();

                curvaDAO = DaoFactory.getCurvaDAO();

                listaCurvasVigentes = curvaDAO.ObterCurvasVigentePorTipoMesaOrigemCategoria(mesaID, tipoCurvaID, categoriaID, codigoSituacaoAtiva, codigoSituacaoPendente);

                //Obtém a curva referente a cada curva vigente
                foreach (CurvaVigente item in listaCurvasVigentes)
                {
                    Curva curva = curvaDAO.ObterCurva(item.CodigoCurvaVigente);

                    item.CurvaReferencia = new CurvaReferencia()
                    {
                        CodigoCurva = curva.CodigoCurva,
                        NomeCurva = curva.NomeCurva
                    };
                }

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<CurvaVigente>(listaCurvasVigentes, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                listaCurvasVigentes = null;
            }

            return new List<CurvaVigente>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 12/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método "ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntrada".               <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="codigoSubmesa">codigoSubmesa</param>
        /// <param name="codigoTipoCurva">codigoTipoCurva</param>
        /// <param name="codigoCategoriaMercado">codigoCategoriaMercado</param>
        /// <param name="codigoSituacaoAtiva">codigoSituacaoAtiva</param>
        /// <param name="codigoSituacaoPendente">codigoSituacaoPendente</param>
        /// <param name="codigoTipoEntradaDado">codigoTipoEntradaDado</param>
        /// <returns>Lista de Curva</returns>
        public IList<Curva> ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntrada(int codigoSubmesa, int codigoTipoCurva,
            int codigoCategoriaMercado, int codigoSituacaoAtiva, int codigoSituacaoPendente, int codigoTipoEntradaDado)
        {
            ICurvaDAO curvaDAO;
            IList<Curva> listaCurvas;
            Curva curva;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                listaCurvas = curvaDAO.ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntrada(codigoSubmesa, codigoTipoCurva,
                                                                                        codigoCategoriaMercado, codigoSituacaoAtiva,
                                                                                        codigoSituacaoPendente, codigoTipoEntradaDado);

                foreach (Curva item in listaCurvas)
                {
                    curva = curvaDAO.ObterCurva(item.CodigoCurva);

                    item.DescricaoCurva = curva.DescricaoCurva;
                    item.QuantidadeAnoExtensao = curva.QuantidadeAnoExtensao;
                }

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<Curva>(listaCurvas, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                listaCurvas = null;
            }

            return new List<Curva>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 08/09/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterCurvasRetidasPorTipoMesaCategoriaSituacao.                          <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="tipoCurvaID">tipoCurvaID</param>
        /// <param name="subMesaID">subMesaID</param>
        /// <param name="categoriaMercadoID">categoriaMercadoID</param>
        /// <param name="codigoSituacao">codigoSituacao</param>
        /// <returns>Lista de objetos "Curva".</returns>
        public IList<Curva> ObterCurvasRetidasPorTipoMesaCategoriaSituacao(int tipoCurvaID, int subMesaID, int categoriaMercadoID, int codigoSituacao)
        {
            IList<Curva> listaCurva;
            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                listaCurva = curvaDAO.ObterCurvasRetidasPorTipoMesaCategoriaSituacao(tipoCurvaID, subMesaID, categoriaMercadoID, codigoSituacao);

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<Curva>(listaCurva, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                listaCurva = null;
            }

            return new List<Curva>();
        }

        public IList<CurvaVigente> ObterCurvasCompostasVigentesPeloFator(int codigoCurvaComponente)
        {
            ICurvaDAO curvaDAO;
            IList<CurvaVigente> curvas;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                curvas = curvaDAO.ObterCurvasCompostasVigentesPeloFator(codigoCurvaComponente);

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<CurvaVigente>(curvas, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                curvas = null;
            }

            return new List<CurvaVigente>();
        }

        public int ObterMinimoAnosExtensaoCurvas(IList<Curva> curvas)
        {
            ICurvaDAO curvaDAO;
            int menorAnoExtensaoCurvas = int.MaxValue;
            int retorno = 0;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                foreach (Curva item in curvas)
                {
                    // Chamara o métod ObterMáximoAnosExtensaoCurvas
                    retorno = curvaDAO.ObterDadosBasicosCurva(item.CodigoCurva).QuantidadeAnoExtensao;
                    // Verifica se o retono é menor que o valor armazenado
                    if (menorAnoExtensaoCurvas > retorno)
                        menorAnoExtensaoCurvas = retorno;
                }

                return menorAnoExtensaoCurvas;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return 0;
        }

        public IList<ModeloIntervaloTolerancia> ObterIntervalosTolerancia()
        {
            IList<ModeloIntervaloTolerancia> listaRetorno = null;

            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();
                listaRetorno = curvaDAO.ObterIntervalosTolerancia();
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRetorno = null;
            }

            return new List<ModeloIntervaloTolerancia>();
        }

        public ImportacaoArquivo ObterDadosArquivoImportacao(int codigoCurva, DateTime dataInclusaoVigencia)
        {

            ICurvaDAO curvaDAO;
            ImportacaoArquivo importacaoArquivo;

            try
            {
                importacaoArquivo = new ImportacaoArquivo();
                curvaDAO = DaoFactory.getCurvaDAO();
                importacaoArquivo = curvaDAO.ObterDadosArquivoImportacao(codigoCurva, dataInclusaoVigencia);
                return importacaoArquivo;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                importacaoArquivo = null;
            }

            return new ImportacaoArquivo();
        }

        public void AtualizarCurvaVigente(CurvaVigente curvaVigente)
        {
            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curvaVigente.CodigoCurvaVigente, Itau.IM.CAS.TipoAcesso.Ativacao))
                    {
                        curvaDAO.AtualizarCurvaVigente(curvaVigente);
                    }
                    else
                    {
                        System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
                throw ex;
            }
        }

        public IList<ParametroModeloIntervaloTolerancia> ObterParametrosModeloIntervaloTolerancia(int codigoModelo)
        {
            ICurvaDAO curvaDAO;
            IList<ParametroModeloIntervaloTolerancia> listaRetorno = null;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                listaRetorno = curvaDAO.ObterParametrosModeloIntervaloTolerancia(codigoModelo);
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRetorno = null;
            }

            return new List<ParametroModeloIntervaloTolerancia>();
        }

        public IList<TaxaPontoCurvaVigente> ObterMetodosInterpolacaoCurva(int codigoCurva, DateTime dataInclusaoVigencia)
        {

            ICurvaDAO curvaDAO;
            IList<TaxaPontoCurvaVigente> listaRetorno = null;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                listaRetorno = curvaDAO.ObterMetodosInterpolacaoCurva(codigoCurva, dataInclusaoVigencia);
                return listaRetorno;
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                listaRetorno = null;
            }

            return new List<TaxaPontoCurvaVigente>();
        }

        public void CriarIntervaloTolerancia(ModeloIntervaloTolerancia modeloIntervaloTolerancia)
        {

            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                curvaDAO.CriarIntervaloTolerancia(modeloIntervaloTolerancia);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                modeloIntervaloTolerancia = null;
            }
        }

        public void AtualizarIntervaloTolerancia(ModeloIntervaloTolerancia modeloIntervaloTolerancia)
        {

            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                curvaDAO.AtualizarIntervaloTolerancia(modeloIntervaloTolerancia);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                modeloIntervaloTolerancia = null;
            }
        }

        public void RemoverIntervaloTolerancia(int codigoModeloIntervaloTolerancia)
        {

            ICurvaDAO curvaDAO;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                curvaDAO.RemoverIntervaloTolerancia(codigoModeloIntervaloTolerancia);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
            }
        }

        public ComposicaoCurva ObterCurvaComposicaoVigente(int codigoCurva, DateTime dataInclusaoVigencia)
        {
            ICurvaDAO curvaDAO;
            ComposicaoCurva composicaoCurva = new ComposicaoCurva();
            IList<ItemComposicao> listaItens = new List<ItemComposicao>();

            try
            {
                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, codigoCurva, Itau.IM.CAS.TipoAcesso.Consulta))
                    {
                        curvaDAO = DaoFactory.getCurvaDAO();

                        composicaoCurva = curvaDAO.ObterCurvaComposicaoVigente(codigoCurva, dataInclusaoVigencia);

                        composicaoCurva.Itens = curvaDAO.ObterItensComposicao(codigoCurva, dataInclusaoVigencia);

                        return composicaoCurva;
                    }
                    else
                    {
                        try
                        {
                            System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                        }
                        catch
                        {
                        }
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                composicaoCurva = null;
                listaItens = null;
            }

            return null;
        }
        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Cosin                                                                           <BR/>
        /// DATA DE CRIAÇÃO : 25/03/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterCurvasPorNome.                                                      <BR/>
        /// **************************************************************************************************<BR/> 
        public IList<Curva> ObterCurvasPorNome(string nome)
        {
            ICurvaDAO curvaDAO;
            IList<Curva> curvas;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                curvas = curvaDAO.ObterCurvasPorNome(nome);

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<Curva>(curvas, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                throw ex;
            }
            finally
            {
                curvaDAO = null;
                curvas = null;
            }
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Cosin                                                                           <BR/>
        /// DATA DE CRIAÇÃO : 01/04/2011                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método ObterTodosTipotaxa.                                                      <BR/>
        /// **************************************************************************************************<BR/> 
        public IList<TipoTaxa> ObterTodosTiposTaxa()
        {
            IList<TipoTaxa> listaTipoTaxa = null;

            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();
                listaTipoTaxa = curvaDAO.ObterTodosTiposTaxa();
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return listaTipoTaxa;
        }

        public IList<CurvaVigente> ObterCurvasVigentesPMT(int codigoCurvaPMT)
        {

            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();
                return curvaDAO.ObterCurvasVigentesPMT(codigoCurvaPMT);
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }

            return new List<CurvaVigente>();
        }

        /// <summary>
        /// **************************************************************************************************<BR/>
        /// AUTOR           : Fábrica de Software                                                             <BR/>
        /// DATA DE CRIAÇÃO : 12/08/2010                                                                      <BR/>
        /// ALTERADO POR    :                                                                                 <BR/>
        /// DATA ALTERAÇÃO  :                                                                                 <BR/>
        /// OBJETIVO        : Método "ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntradaFacultativo".    <BR/>
        /// **************************************************************************************************<BR/> 
        /// </summary>
        /// <param name="codigoSubmesa">codigoSubmesa</param>
        /// <param name="codigoTipoCurva">codigoTipoCurva</param>
        /// <param name="codigoCategoriaMercado">codigoCategoriaMercado</param>
        /// <param name="codigoSituacaoAtiva">codigoSituacaoAtiva</param>
        /// <param name="codigoSituacaoPendente">codigoSituacaoPendente</param>
        /// <param name="codigoTipoEntradaDado">codigoTipoEntradaDado</param>
        /// <returns>Lista de Curva</returns>
        public IList<Curva> ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntradaFacultativo(int codigoSubmesa, int codigoTipoCurva,
            int codigoCategoriaMercado, int codigoSituacaoAtiva, int codigoSituacaoPendente, int codigoTipoEntradaDado)
        {
            ICurvaDAO curvaDAO;
            IList<Curva> listaCurvas;

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();

                listaCurvas = curvaDAO.ObterCurvasVigentePorTipoMesaOrigemCategoriaTipoEntradaFacultativo(codigoSubmesa, codigoTipoCurva,
                                                                                        codigoCategoriaMercado, codigoSituacaoAtiva,
                                                                                        codigoSituacaoPendente, codigoTipoEntradaDado);

                //Implementação de tratamento para controle de acesso
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<Curva>(listaCurvas, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvaDAO = null;
                listaCurvas = null;
            }

            return new List<Curva>();
        }

        #endregion

        #region //URICK 26/10/2012

        public IList<Curva> ObterTodasCurvasParaSelecaoEnvioTesouraria()
        {
            ICurvaDAO curvaDAO;
            IList<Curva> curvas = new List<Curva>();

            try
            {
                curvaDAO = DaoFactory.getCurvaDAO();
                curvas = curvaDAO.ObterTodasCurvasParaSelecaoEnvioTesouraria();

                //URICK Verificar se é preciso fazer esta interação
                using (IntegracaoCAS CAS = new IntegracaoCAS())
                {
                    return CAS.FiltrarRegistros<Curva>(curvas, DominioAcesso.Curva, Itau.IM.CAS.TipoAcesso.Consulta);
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            finally
            {
                curvas = null;
            }
            return curvas;
        }

        public bool SelecionarCurvasParaEnvioTesouraria(IList<Curva> curvas)
        {
            try
            {
                ICurvaDAO curvaDAO = DaoFactory.getCurvaDAO();
                foreach (Curva curva in curvas)
                {
                    using (IntegracaoCAS CAS = new IntegracaoCAS())
                    {
                        if (CAS.VerificarAcessoUsuario(DominioAcesso.Curva, curva.CodigoCurva, Itau.IM.CAS.TipoAcesso.Ativacao))
                        {
                            curvaDAO.SelecionarCurvasParaEnvioTesouraria(curva);
                        }
                        else
                        {
                            System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
                        }
                    }
                }
            }
            catch (DadosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (NegociosException ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
            }
            catch (CASException)
            {
                System.ServiceModel.Web.WebOperationContext.Current.OutgoingResponse.StatusCode = System.Net.HttpStatusCode.Unauthorized;
            }
            catch (Exception ex)
            {
                EnterpriseLibraryFactory.GetExceptionHandler().HandleException(ex, "ErrosNegocios");
                throw ex;
            }
            return false;
        }

        #endregion
    }
}